home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2007 September / PCWSEP07.iso / Software / Linux / Linux Mint 3.0 Light / LinuxMint-3.0-Light.iso / casper / filesystem.squashfs / usr / lib / python2.5 / urllib2.py < prev    next >
Encoding:
Python Source  |  2007-05-02  |  46.1 KB  |  1,354 lines
  1. """An extensible library for opening URLs using a variety of protocols
  2.  
  3. The simplest way to use this module is to call the urlopen function,
  4. which accepts a string containing a URL or a Request object (described
  5. below).  It opens the URL and returns the results as file-like
  6. object; the returned object has some extra methods described below.
  7.  
  8. The OpenerDirector manages a collection of Handler objects that do
  9. all the actual work.  Each Handler implements a particular protocol or
  10. option.  The OpenerDirector is a composite object that invokes the
  11. Handlers needed to open the requested URL.  For example, the
  12. HTTPHandler performs HTTP GET and POST requests and deals with
  13. non-error returns.  The HTTPRedirectHandler automatically deals with
  14. HTTP 301, 302, 303 and 307 redirect errors, and the HTTPDigestAuthHandler
  15. deals with digest authentication.
  16.  
  17. urlopen(url, data=None) -- basic usage is the same as original
  18. urllib.  pass the url and optionally data to post to an HTTP URL, and
  19. get a file-like object back.  One difference is that you can also pass
  20. a Request instance instead of URL.  Raises a URLError (subclass of
  21. IOError); for HTTP errors, raises an HTTPError, which can also be
  22. treated as a valid response.
  23.  
  24. build_opener -- function that creates a new OpenerDirector instance.
  25. will install the default handlers.  accepts one or more Handlers as
  26. arguments, either instances or Handler classes that it will
  27. instantiate.  if one of the argument is a subclass of the default
  28. handler, the argument will be installed instead of the default.
  29.  
  30. install_opener -- installs a new opener as the default opener.
  31.  
  32. objects of interest:
  33. OpenerDirector --
  34.  
  35. Request -- an object that encapsulates the state of a request.  the
  36. state can be a simple as the URL.  it can also include extra HTTP
  37. headers, e.g. a User-Agent.
  38.  
  39. BaseHandler --
  40.  
  41. exceptions:
  42. URLError-- a subclass of IOError, individual protocols have their own
  43. specific subclass
  44.  
  45. HTTPError-- also a valid HTTP response, so you can treat an HTTP error
  46. as an exceptional event or valid response
  47.  
  48. internals:
  49. BaseHandler and parent
  50. _call_chain conventions
  51.  
  52. Example usage:
  53.  
  54. import urllib2
  55.  
  56. # set up authentication info
  57. authinfo = urllib2.HTTPBasicAuthHandler()
  58. authinfo.add_password('realm', 'host', 'username', 'password')
  59.  
  60. proxy_support = urllib2.ProxyHandler({"http" : "http://ahad-haam:3128"})
  61.  
  62. # build a new opener that adds authentication and caching FTP handlers
  63. opener = urllib2.build_opener(proxy_support, authinfo, urllib2.CacheFTPHandler)
  64.  
  65. # install it
  66. urllib2.install_opener(opener)
  67.  
  68. f = urllib2.urlopen('http://www.python.org/')
  69.  
  70.  
  71. """
  72.  
  73. # XXX issues:
  74. # If an authentication error handler that tries to perform
  75. # authentication for some reason but fails, how should the error be
  76. # signalled?  The client needs to know the HTTP error code.  But if
  77. # the handler knows that the problem was, e.g., that it didn't know
  78. # that hash algo that requested in the challenge, it would be good to
  79. # pass that information along to the client, too.
  80. # ftp errors aren't handled cleanly
  81. # check digest against correct (i.e. non-apache) implementation
  82.  
  83. # Possible extensions:
  84. # complex proxies  XXX not sure what exactly was meant by this
  85. # abstract factory for opener
  86.  
  87. import base64
  88. import hashlib
  89. import httplib
  90. import mimetools
  91. import os
  92. import posixpath
  93. import random
  94. import re
  95. import socket
  96. import sys
  97. import time
  98. import urlparse
  99. import bisect
  100.  
  101. try:
  102.     from cStringIO import StringIO
  103. except ImportError:
  104.     from StringIO import StringIO
  105.  
  106. from urllib import (unwrap, unquote, splittype, splithost, quote,
  107.      addinfourl, splitport, splitgophertype, splitquery,
  108.      splitattr, ftpwrapper, noheaders, splituser, splitpasswd, splitvalue)
  109.  
  110. # support for FileHandler, proxies via environment variables
  111. from urllib import localhost, url2pathname, getproxies
  112.  
  113. # used in User-Agent header sent
  114. __version__ = sys.version[:3]
  115.  
  116. _opener = None
  117. def urlopen(url, data=None):
  118.     global _opener
  119.     if _opener is None:
  120.         _opener = build_opener()
  121.     return _opener.open(url, data)
  122.  
  123. def install_opener(opener):
  124.     global _opener
  125.     _opener = opener
  126.  
  127. # do these error classes make sense?
  128. # make sure all of the IOError stuff is overridden.  we just want to be
  129. # subtypes.
  130.  
  131. class URLError(IOError):
  132.     # URLError is a sub-type of IOError, but it doesn't share any of
  133.     # the implementation.  need to override __init__ and __str__.
  134.     # It sets self.args for compatibility with other EnvironmentError
  135.     # subclasses, but args doesn't have the typical format with errno in
  136.     # slot 0 and strerror in slot 1.  This may be better than nothing.
  137.     def __init__(self, reason):
  138.         self.args = reason,
  139.         self.reason = reason
  140.  
  141.     def __str__(self):
  142.         return '<urlopen error %s>' % self.reason
  143.  
  144. class HTTPError(URLError, addinfourl):
  145.     """Raised when HTTP error occurs, but also acts like non-error return"""
  146.     __super_init = addinfourl.__init__
  147.  
  148.     def __init__(self, url, code, msg, hdrs, fp):
  149.         self.code = code
  150.         self.msg = msg
  151.         self.hdrs = hdrs
  152.         self.fp = fp
  153.         self.filename = url
  154.         # The addinfourl classes depend on fp being a valid file
  155.         # object.  In some cases, the HTTPError may not have a valid
  156.         # file object.  If this happens, the simplest workaround is to
  157.         # not initialize the base classes.
  158.         if fp is not None:
  159.             self.__super_init(fp, hdrs, url)
  160.  
  161.     def __str__(self):
  162.         return 'HTTP Error %s: %s' % (self.code, self.msg)
  163.  
  164. class GopherError(URLError):
  165.     pass
  166.  
  167. # copied from cookielib.py
  168. _cut_port_re = re.compile(r":\d+$")
  169. def request_host(request):
  170.     """Return request-host, as defined by RFC 2965.
  171.  
  172.     Variation from RFC: returned value is lowercased, for convenient
  173.     comparison.
  174.  
  175.     """
  176.     url = request.get_full_url()
  177.     host = urlparse.urlparse(url)[1]
  178.     if host == "":
  179.         host = request.get_header("Host", "")
  180.  
  181.     # remove port, if present
  182.     host = _cut_port_re.sub("", host, 1)
  183.     return host.lower()
  184.  
  185. class Request:
  186.  
  187.     def __init__(self, url, data=None, headers={},
  188.                  origin_req_host=None, unverifiable=False):
  189.         # unwrap('<URL:type://host/path>') --> 'type://host/path'
  190.         self.__original = unwrap(url)
  191.         self.type = None
  192.         # self.__r_type is what's left after doing the splittype
  193.         self.host = None
  194.         self.port = None
  195.         self.data = data
  196.         self.headers = {}
  197.         for key, value in headers.items():
  198.             self.add_header(key, value)
  199.         self.unredirected_hdrs = {}
  200.         if origin_req_host is None:
  201.             origin_req_host = request_host(self)
  202.         self.origin_req_host = origin_req_host
  203.         self.unverifiable = unverifiable
  204.  
  205.     def __getattr__(self, attr):
  206.         # XXX this is a fallback mechanism to guard against these
  207.         # methods getting called in a non-standard order.  this may be
  208.         # too complicated and/or unnecessary.
  209.         # XXX should the __r_XXX attributes be public?
  210.         if attr[:12] == '_Request__r_':
  211.             name = attr[12:]
  212.             if hasattr(Request, 'get_' + name):
  213.                 getattr(self, 'get_' + name)()
  214.                 return getattr(self, attr)
  215.         raise AttributeError, attr
  216.  
  217.     def get_method(self):
  218.         if self.has_data():
  219.             return "POST"
  220.         else:
  221.             return "GET"
  222.  
  223.     # XXX these helper methods are lame
  224.  
  225.     def add_data(self, data):
  226.         self.data = data
  227.  
  228.     def has_data(self):
  229.         return self.data is not None
  230.  
  231.     def get_data(self):
  232.         return self.data
  233.  
  234.     def get_full_url(self):
  235.         return self.__original
  236.  
  237.     def get_type(self):
  238.         if self.type is None:
  239.             self.type, self.__r_type = splittype(self.__original)
  240.             if self.type is None:
  241.                 raise ValueError, "unknown url type: %s" % self.__original
  242.         return self.type
  243.  
  244.     def get_host(self):
  245.         if self.host is None:
  246.             self.host, self.__r_host = splithost(self.__r_type)
  247.             if self.host:
  248.                 self.host = unquote(self.host)
  249.         return self.host
  250.  
  251.     def get_selector(self):
  252.         return self.__r_host
  253.  
  254.     def set_proxy(self, host, type):
  255.         self.host, self.type = host, type
  256.         self.__r_host = self.__original
  257.  
  258.     def get_origin_req_host(self):
  259.         return self.origin_req_host
  260.  
  261.     def is_unverifiable(self):
  262.         return self.unverifiable
  263.  
  264.     def add_header(self, key, val):
  265.         # useful for something like authentication
  266.         self.headers[key.capitalize()] = val
  267.  
  268.     def add_unredirected_header(self, key, val):
  269.         # will not be added to a redirected request
  270.         self.unredirected_hdrs[key.capitalize()] = val
  271.  
  272.     def has_header(self, header_name):
  273.         return (header_name in self.headers or
  274.                 header_name in self.unredirected_hdrs)
  275.  
  276.     def get_header(self, header_name, default=None):
  277.         return self.headers.get(
  278.             header_name,
  279.             self.unredirected_hdrs.get(header_name, default))
  280.  
  281.     def header_items(self):
  282.         hdrs = self.unredirected_hdrs.copy()
  283.         hdrs.update(self.headers)
  284.         return hdrs.items()
  285.  
  286. class OpenerDirector:
  287.     def __init__(self):
  288.         client_version = "Python-urllib/%s" % __version__
  289.         self.addheaders = [('User-agent', client_version)]
  290.         # manage the individual handlers
  291.         self.handlers = []
  292.         self.handle_open = {}
  293.         self.handle_error = {}
  294.         self.process_response = {}
  295.         self.process_request = {}
  296.  
  297.     def add_handler(self, handler):
  298.         added = False
  299.         for meth in dir(handler):
  300.             if meth in ["redirect_request", "do_open", "proxy_open"]:
  301.                 # oops, coincidental match
  302.                 continue
  303.  
  304.             i = meth.find("_")
  305.             protocol = meth[:i]
  306.             condition = meth[i+1:]
  307.  
  308.             if condition.startswith("error"):
  309.                 j = condition.find("_") + i + 1
  310.                 kind = meth[j+1:]
  311.                 try:
  312.                     kind = int(kind)
  313.                 except ValueError:
  314.                     pass
  315.                 lookup = self.handle_error.get(protocol, {})
  316.                 self.handle_error[protocol] = lookup
  317.             elif condition == "open":
  318.                 kind = protocol
  319.                 lookup = self.handle_open
  320.             elif condition == "response":
  321.                 kind = protocol
  322.                 lookup = self.process_response
  323.             elif condition == "request":
  324.                 kind = protocol
  325.                 lookup = self.process_request
  326.             else:
  327.                 continue
  328.  
  329.             handlers = lookup.setdefault(kind, [])
  330.             if handlers:
  331.                 bisect.insort(handlers, handler)
  332.             else:
  333.                 handlers.append(handler)
  334.             added = True
  335.  
  336.         if added:
  337.             # XXX why does self.handlers need to be sorted?
  338.             bisect.insort(self.handlers, handler)
  339.             handler.add_parent(self)
  340.  
  341.     def close(self):
  342.         # Only exists for backwards compatibility.
  343.         pass
  344.  
  345.     def _call_chain(self, chain, kind, meth_name, *args):
  346.         # Handlers raise an exception if no one else should try to handle
  347.         # the request, or return None if they can't but another handler
  348.         # could.  Otherwise, they return the response.
  349.         handlers = chain.get(kind, ())
  350.         for handler in handlers:
  351.             func = getattr(handler, meth_name)
  352.  
  353.             result = func(*args)
  354.             if result is not None:
  355.                 return result
  356.  
  357.     def open(self, fullurl, data=None):
  358.         # accept a URL or a Request object
  359.         if isinstance(fullurl, basestring):
  360.             req = Request(fullurl, data)
  361.         else:
  362.             req = fullurl
  363.             if data is not None:
  364.                 req.add_data(data)
  365.  
  366.         protocol = req.get_type()
  367.  
  368.         # pre-process request
  369.         meth_name = protocol+"_request"
  370.         for processor in self.process_request.get(protocol, []):
  371.             meth = getattr(processor, meth_name)
  372.             req = meth(req)
  373.  
  374.         response = self._open(req, data)
  375.  
  376.         # post-process response
  377.         meth_name = protocol+"_response"
  378.         for processor in self.process_response.get(protocol, []):
  379.             meth = getattr(processor, meth_name)
  380.             response = meth(req, response)
  381.  
  382.         return response
  383.  
  384.     def _open(self, req, data=None):
  385.         result = self._call_chain(self.handle_open, 'default',
  386.                                   'default_open', req)
  387.         if result:
  388.             return result
  389.  
  390.         protocol = req.get_type()
  391.         result = self._call_chain(self.handle_open, protocol, protocol +
  392.                                   '_open', req)
  393.         if result:
  394.             return result
  395.  
  396.         return self._call_chain(self.handle_open, 'unknown',
  397.                                 'unknown_open', req)
  398.  
  399.     def error(self, proto, *args):
  400.         if proto in ('http', 'https'):
  401.             # XXX http[s] protocols are special-cased
  402.             dict = self.handle_error['http'] # https is not different than http
  403.             proto = args[2]  # YUCK!
  404.             meth_name = 'http_error_%s' % proto
  405.             http_err = 1
  406.             orig_args = args
  407.         else:
  408.             dict = self.handle_error
  409.             meth_name = proto + '_error'
  410.             http_err = 0
  411.         args = (dict, proto, meth_name) + args
  412.         result = self._call_chain(*args)
  413.         if result:
  414.             return result
  415.  
  416.         if http_err:
  417.             args = (dict, 'default', 'http_error_default') + orig_args
  418.             return self._call_chain(*args)
  419.  
  420. # XXX probably also want an abstract factory that knows when it makes
  421. # sense to skip a superclass in favor of a subclass and when it might
  422. # make sense to include both
  423.  
  424. def build_opener(*handlers):
  425.     """Create an opener object from a list of handlers.
  426.  
  427.     The opener will use several default handlers, including support
  428.     for HTTP and FTP.
  429.  
  430.     If any of the handlers passed as arguments are subclasses of the
  431.     default handlers, the default handlers will not be used.
  432.     """
  433.     import types
  434.     def isclass(obj):
  435.         return isinstance(obj, types.ClassType) or hasattr(obj, "__bases__")
  436.  
  437.     opener = OpenerDirector()
  438.     default_classes = [ProxyHandler, UnknownHandler, HTTPHandler,
  439.                        HTTPDefaultErrorHandler, HTTPRedirectHandler,
  440.                        FTPHandler, FileHandler, HTTPErrorProcessor]
  441.     if hasattr(httplib, 'HTTPS'):
  442.         default_classes.append(HTTPSHandler)
  443.     skip = []
  444.     for klass in default_classes:
  445.         for check in handlers:
  446.             if isclass(check):
  447.                 if issubclass(check, klass):
  448.                     skip.append(klass)
  449.             elif isinstance(check, klass):
  450.                 skip.append(klass)
  451.     for klass in skip:
  452.         default_classes.remove(klass)
  453.  
  454.     for klass in default_classes:
  455.         opener.add_handler(klass())
  456.  
  457.     for h in handlers:
  458.         if isclass(h):
  459.             h = h()
  460.         opener.add_handler(h)
  461.     return opener
  462.  
  463. class BaseHandler:
  464.     handler_order = 500
  465.  
  466.     def add_parent(self, parent):
  467.         self.parent = parent
  468.  
  469.     def close(self):
  470.         # Only exists for backwards compatibility
  471.         pass
  472.  
  473.     def __lt__(self, other):
  474.         if not hasattr(other, "handler_order"):
  475.             # Try to preserve the old behavior of having custom classes
  476.             # inserted after default ones (works only for custom user
  477.             # classes which are not aware of handler_order).
  478.             return True
  479.         return self.handler_order < other.handler_order
  480.  
  481.  
  482. class HTTPErrorProcessor(BaseHandler):
  483.     """Process HTTP error responses."""
  484.     handler_order = 1000  # after all other processing
  485.  
  486.     def http_response(self, request, response):
  487.         code, msg, hdrs = response.code, response.msg, response.info()
  488.  
  489.         if code not in (200, 206):
  490.             response = self.parent.error(
  491.                 'http', request, response, code, msg, hdrs)
  492.  
  493.         return response
  494.  
  495.     https_response = http_response
  496.  
  497. class HTTPDefaultErrorHandler(BaseHandler):
  498.     def http_error_default(self, req, fp, code, msg, hdrs):
  499.         raise HTTPError(req.get_full_url(), code, msg, hdrs, fp)
  500.  
  501. class HTTPRedirectHandler(BaseHandler):
  502.     # maximum number of redirections to any single URL
  503.     # this is needed because of the state that cookies introduce
  504.     max_repeats = 4
  505.     # maximum total number of redirections (regardless of URL) before
  506.     # assuming we're in a loop
  507.     max_redirections = 10
  508.  
  509.     def redirect_request(self, req, fp, code, msg, headers, newurl):
  510.         """Return a Request or None in response to a redirect.
  511.  
  512.         This is called by the http_error_30x methods when a
  513.         redirection response is received.  If a redirection should
  514.         take place, return a new Request to allow http_error_30x to
  515.         perform the redirect.  Otherwise, raise HTTPError if no-one
  516.         else should try to handle this url.  Return None if you can't
  517.         but another Handler might.
  518.         """
  519.         m = req.get_method()
  520.         if (code in (301, 302, 303, 307) and m in ("GET", "HEAD")
  521.             or code in (301, 302, 303) and m == "POST"):
  522.             # Strictly (according to RFC 2616), 301 or 302 in response
  523.             # to a POST MUST NOT cause a redirection without confirmation
  524.             # from the user (of urllib2, in this case).  In practice,
  525.             # essentially all clients do redirect in this case, so we
  526.             # do the same.
  527.             # be conciliant with URIs containing a space
  528.             newurl = newurl.replace(' ', '%20')
  529.             return Request(newurl,
  530.                            headers=req.headers,
  531.                            origin_req_host=req.get_origin_req_host(),
  532.                            unverifiable=True)
  533.         else:
  534.             raise HTTPError(req.get_full_url(), code, msg, headers, fp)
  535.  
  536.     # Implementation note: To avoid the server sending us into an
  537.     # infinite loop, the request object needs to track what URLs we
  538.     # have already seen.  Do this by adding a handler-specific
  539.     # attribute to the Request object.
  540.     def http_error_302(self, req, fp, code, msg, headers):
  541.         # Some servers (incorrectly) return multiple Location headers
  542.         # (so probably same goes for URI).  Use first header.
  543.         if 'location' in headers:
  544.             newurl = headers.getheaders('location')[0]
  545.         elif 'uri' in headers:
  546.             newurl = headers.getheaders('uri')[0]
  547.         else:
  548.             return
  549.         newurl = urlparse.urljoin(req.get_full_url(), newurl)
  550.  
  551.         # XXX Probably want to forget about the state of the current
  552.         # request, although that might interact poorly with other
  553.         # handlers that also use handler-specific request attributes
  554.         new = self.redirect_request(req, fp, code, msg, headers, newurl)
  555.         if new is None:
  556.             return
  557.  
  558.         # loop detection
  559.         # .redirect_dict has a key url if url was previously visited.
  560.         if hasattr(req, 'redirect_dict'):
  561.             visited = new.redirect_dict = req.redirect_dict
  562.             if (visited.get(newurl, 0) >= self.max_repeats or
  563.                 len(visited) >= self.max_redirections):
  564.                 raise HTTPError(req.get_full_url(), code,
  565.                                 self.inf_msg + msg, headers, fp)
  566.         else:
  567.             visited = new.redirect_dict = req.redirect_dict = {}
  568.         visited[newurl] = visited.get(newurl, 0) + 1
  569.  
  570.         # Don't close the fp until we are sure that we won't use it
  571.         # with HTTPError.
  572.         fp.read()
  573.         fp.close()
  574.  
  575.         return self.parent.open(new)
  576.  
  577.     http_error_301 = http_error_303 = http_error_307 = http_error_302
  578.  
  579.     inf_msg = "The HTTP server returned a redirect error that would " \
  580.               "lead to an infinite loop.\n" \
  581.               "The last 30x error message was:\n"
  582.  
  583.  
  584. def _parse_proxy(proxy):
  585.     """Return (scheme, user, password, host/port) given a URL or an authority.
  586.  
  587.     If a URL is supplied, it must have an authority (host:port) component.
  588.     According to RFC 3986, having an authority component means the URL must
  589.     have two slashes after the scheme:
  590.  
  591.     >>> _parse_proxy('file:/ftp.example.com/')
  592.     Traceback (most recent call last):
  593.     ValueError: proxy URL with no authority: 'file:/ftp.example.com/'
  594.  
  595.     The first three items of the returned tuple may be None.
  596.  
  597.     Examples of authority parsing:
  598.  
  599.     >>> _parse_proxy('proxy.example.com')
  600.     (None, None, None, 'proxy.example.com')
  601.     >>> _parse_proxy('proxy.example.com:3128')
  602.     (None, None, None, 'proxy.example.com:3128')
  603.  
  604.     The authority component may optionally include userinfo (assumed to be
  605.     username:password):
  606.  
  607.     >>> _parse_proxy('joe:password@proxy.example.com')
  608.     (None, 'joe', 'password', 'proxy.example.com')
  609.     >>> _parse_proxy('joe:password@proxy.example.com:3128')
  610.     (None, 'joe', 'password', 'proxy.example.com:3128')
  611.  
  612.     Same examples, but with URLs instead:
  613.  
  614.     >>> _parse_proxy('http://proxy.example.com/')
  615.     ('http', None, None, 'proxy.example.com')
  616.     >>> _parse_proxy('http://proxy.example.com:3128/')
  617.     ('http', None, None, 'proxy.example.com:3128')
  618.     >>> _parse_proxy('http://joe:password@proxy.example.com/')
  619.     ('http', 'joe', 'password', 'proxy.example.com')
  620.     >>> _parse_proxy('http://joe:password@proxy.example.com:3128')
  621.     ('http', 'joe', 'password', 'proxy.example.com:3128')
  622.  
  623.     Everything after the authority is ignored:
  624.  
  625.     >>> _parse_proxy('ftp://joe:password@proxy.example.com/rubbish:3128')
  626.     ('ftp', 'joe', 'password', 'proxy.example.com')
  627.  
  628.     Test for no trailing '/' case:
  629.  
  630.     >>> _parse_proxy('http://joe:password@proxy.example.com')
  631.     ('http', 'joe', 'password', 'proxy.example.com')
  632.  
  633.     """
  634.     scheme, r_scheme = splittype(proxy)
  635.     if not r_scheme.startswith("/"):
  636.         # authority
  637.         scheme = None
  638.         authority = proxy
  639.     else:
  640.         # URL
  641.         if not r_scheme.startswith("//"):
  642.             raise ValueError("proxy URL with no authority: %r" % proxy)
  643.         # We have an authority, so for RFC 3986-compliant URLs (by ss 3.
  644.         # and 3.3.), path is empty or starts with '/'
  645.         end = r_scheme.find("/", 2)
  646.         if end == -1:
  647.             end = None
  648.         authority = r_scheme[2:end]
  649.     userinfo, hostport = splituser(authority)
  650.     if userinfo is not None:
  651.         user, password = splitpasswd(userinfo)
  652.     else:
  653.         user = password = None
  654.     return scheme, user, password, hostport
  655.  
  656. class ProxyHandler(BaseHandler):
  657.     # Proxies must be in front
  658.     handler_order = 100
  659.  
  660.     def __init__(self, proxies=None):
  661.         if proxies is None:
  662.             proxies = getproxies()
  663.         assert hasattr(proxies, 'has_key'), "proxies must be a mapping"
  664.         self.proxies = proxies
  665.         for type, url in proxies.items():
  666.             setattr(self, '%s_open' % type,
  667.                     lambda r, proxy=url, type=type, meth=self.proxy_open: \
  668.                     meth(r, proxy, type))
  669.  
  670.     def proxy_open(self, req, proxy, type):
  671.         orig_type = req.get_type()
  672.         proxy_type, user, password, hostport = _parse_proxy(proxy)
  673.         if proxy_type is None:
  674.             proxy_type = orig_type
  675.         if user and password:
  676.             user_pass = '%s:%s' % (unquote(user), unquote(password))
  677.             creds = base64.b64encode(user_pass).strip()
  678.             req.add_header('Proxy-authorization', 'Basic ' + creds)
  679.         hostport = unquote(hostport)
  680.         req.set_proxy(hostport, proxy_type)
  681.         if orig_type == proxy_type:
  682.             # let other handlers take care of it
  683.             return None
  684.         else:
  685.             # need to start over, because the other handlers don't
  686.             # grok the proxy's URL type
  687.             # e.g. if we have a constructor arg proxies like so:
  688.             # {'http': 'ftp://proxy.example.com'}, we may end up turning
  689.             # a request for http://acme.example.com/a into one for
  690.             # ftp://proxy.example.com/a
  691.             return self.parent.open(req)
  692.  
  693. class HTTPPasswordMgr:
  694.  
  695.     def __init__(self):
  696.         self.passwd = {}
  697.  
  698.     def add_password(self, realm, uri, user, passwd):
  699.         # uri could be a single URI or a sequence
  700.         if isinstance(uri, basestring):
  701.             uri = [uri]
  702.         if not realm in self.passwd:
  703.             self.passwd[realm] = {}
  704.         for default_port in True, False:
  705.             reduced_uri = tuple(
  706.                 [self.reduce_uri(u, default_port) for u in uri])
  707.             self.passwd[realm][reduced_uri] = (user, passwd)
  708.  
  709.     def find_user_password(self, realm, authuri):
  710.         domains = self.passwd.get(realm, {})
  711.         for default_port in True, False:
  712.             reduced_authuri = self.reduce_uri(authuri, default_port)
  713.             for uris, authinfo in domains.iteritems():
  714.                 for uri in uris:
  715.                     if self.is_suburi(uri, reduced_authuri):
  716.                         return authinfo
  717.         return None, None
  718.  
  719.     def reduce_uri(self, uri, default_port=True):
  720.         """Accept authority or URI and extract only the authority and path."""
  721.         # note HTTP URLs do not have a userinfo component
  722.         parts = urlparse.urlsplit(uri)
  723.         if parts[1]:
  724.             # URI
  725.             scheme = parts[0]
  726.             authority = parts[1]
  727.             path = parts[2] or '/'
  728.         else:
  729.             # host or host:port
  730.             scheme = None
  731.             authority = uri
  732.             path = '/'
  733.         host, port = splitport(authority)
  734.         if default_port and port is None and scheme is not None:
  735.             dport = {"http": 80,
  736.                      "https": 443,
  737.                      }.get(scheme)
  738.             if dport is not None:
  739.                 authority = "%s:%d" % (host, dport)
  740.         return authority, path
  741.  
  742.     def is_suburi(self, base, test):
  743.         """Check if test is below base in a URI tree
  744.  
  745.         Both args must be URIs in reduced form.
  746.         """
  747.         if base == test:
  748.             return True
  749.         if base[0] != test[0]:
  750.             return False
  751.         common = posixpath.commonprefix((base[1], test[1]))
  752.         if len(common) == len(base[1]):
  753.             return True
  754.         return False
  755.  
  756.  
  757. class HTTPPasswordMgrWithDefaultRealm(HTTPPasswordMgr):
  758.  
  759.     def find_user_password(self, realm, authuri):
  760.         user, password = HTTPPasswordMgr.find_user_password(self, realm,
  761.                                                             authuri)
  762.         if user is not None:
  763.             return user, password
  764.         return HTTPPasswordMgr.find_user_password(self, None, authuri)
  765.  
  766.  
  767. class AbstractBasicAuthHandler:
  768.  
  769.     # XXX this allows for multiple auth-schemes, but will stupidly pick
  770.     # the last one with a realm specified.
  771.  
  772.     rx = re.compile('(?:.*,)*[ \t]*([^ \t]+)[ \t]+realm="([^"]*)"', re.I)
  773.  
  774.     # XXX could pre-emptively send auth info already accepted (RFC 2617,
  775.     # end of section 2, and section 1.2 immediately after "credentials"
  776.     # production).
  777.  
  778.     def __init__(self, password_mgr=None):
  779.         if password_mgr is None:
  780.             password_mgr = HTTPPasswordMgr()
  781.         self.passwd = password_mgr
  782.         self.add_password = self.passwd.add_password
  783.  
  784.     def http_error_auth_reqed(self, authreq, host, req, headers):
  785.         # host may be an authority (without userinfo) or a URL with an
  786.         # authority
  787.         # XXX could be multiple headers
  788.         authreq = headers.get(authreq, None)
  789.         if authreq:
  790.             mo = AbstractBasicAuthHandler.rx.search(authreq)
  791.             if mo:
  792.                 scheme, realm = mo.groups()
  793.                 if scheme.lower() == 'basic':
  794.                     return self.retry_http_basic_auth(host, req, realm)
  795.  
  796.     def retry_http_basic_auth(self, host, req, realm):
  797.         user, pw = self.passwd.find_user_password(realm, host)
  798.         if pw is not None:
  799.             raw = "%s:%s" % (user, pw)
  800.             auth = 'Basic %s' % base64.b64encode(raw).strip()
  801.             if req.headers.get(self.auth_header, None) == auth:
  802.                 return None
  803.             req.add_header(self.auth_header, auth)
  804.             return self.parent.open(req)
  805.         else:
  806.             return None
  807.  
  808.  
  809. class HTTPBasicAuthHandler(AbstractBasicAuthHandler, BaseHandler):
  810.  
  811.     auth_header = 'Authorization'
  812.  
  813.     def http_error_401(self, req, fp, code, msg, headers):
  814.         url = req.get_full_url()
  815.         return self.http_error_auth_reqed('www-authenticate',
  816.                                           url, req, headers)
  817.  
  818.  
  819. class ProxyBasicAuthHandler(AbstractBasicAuthHandler, BaseHandler):
  820.  
  821.     auth_header = 'Proxy-authorization'
  822.  
  823.     def http_error_407(self, req, fp, code, msg, headers):
  824.         # http_error_auth_reqed requires that there is no userinfo component in
  825.         # authority.  Assume there isn't one, since urllib2 does not (and
  826.         # should not, RFC 3986 s. 3.2.1) support requests for URLs containing
  827.         # userinfo.
  828.         authority = req.get_host()
  829.         return self.http_error_auth_reqed('proxy-authenticate',
  830.                                           authority, req, headers)
  831.  
  832.  
  833. def randombytes(n):
  834.     """Return n random bytes."""
  835.     # Use /dev/urandom if it is available.  Fall back to random module
  836.     # if not.  It might be worthwhile to extend this function to use
  837.     # other platform-specific mechanisms for getting random bytes.
  838.     if os.path.exists("/dev/urandom"):
  839.         f = open("/dev/urandom")
  840.         s = f.read(n)
  841.         f.close()
  842.         return s
  843.     else:
  844.         L = [chr(random.randrange(0, 256)) for i in range(n)]
  845.         return "".join(L)
  846.  
  847. class AbstractDigestAuthHandler:
  848.     # Digest authentication is specified in RFC 2617.
  849.  
  850.     # XXX The client does not inspect the Authentication-Info header
  851.     # in a successful response.
  852.  
  853.     # XXX It should be possible to test this implementation against
  854.     # a mock server that just generates a static set of challenges.
  855.  
  856.     # XXX qop="auth-int" supports is shaky
  857.  
  858.     def __init__(self, passwd=None):
  859.         if passwd is None:
  860.             passwd = HTTPPasswordMgr()
  861.         self.passwd = passwd
  862.         self.add_password = self.passwd.add_password
  863.         self.retried = 0
  864.         self.nonce_count = 0
  865.  
  866.     def reset_retry_count(self):
  867.         self.retried = 0
  868.  
  869.     def http_error_auth_reqed(self, auth_header, host, req, headers):
  870.         authreq = headers.get(auth_header, None)
  871.         if self.retried > 5:
  872.             # Don't fail endlessly - if we failed once, we'll probably
  873.             # fail a second time. Hm. Unless the Password Manager is
  874.             # prompting for the information. Crap. This isn't great
  875.             # but it's better than the current 'repeat until recursion
  876.             # depth exceeded' approach <wink>
  877.             raise HTTPError(req.get_full_url(), 401, "digest auth failed",
  878.                             headers, None)
  879.         else:
  880.             self.retried += 1
  881.         if authreq:
  882.             scheme = authreq.split()[0]
  883.             if scheme.lower() == 'digest':
  884.                 return self.retry_http_digest_auth(req, authreq)
  885.  
  886.     def retry_http_digest_auth(self, req, auth):
  887.         token, challenge = auth.split(' ', 1)
  888.         chal = parse_keqv_list(parse_http_list(challenge))
  889.         auth = self.get_authorization(req, chal)
  890.         if auth:
  891.             auth_val = 'Digest %s' % auth
  892.             if req.headers.get(self.auth_header, None) == auth_val:
  893.                 return None
  894.             req.add_unredirected_header(self.auth_header, auth_val)
  895.             resp = self.parent.open(req)
  896.             return resp
  897.  
  898.     def get_cnonce(self, nonce):
  899.         # The cnonce-value is an opaque
  900.         # quoted string value provided by the client and used by both client
  901.         # and server to avoid chosen plaintext attacks, to provide mutual
  902.         # authentication, and to provide some message integrity protection.
  903.         # This isn't a fabulous effort, but it's probably Good Enough.
  904.         dig = hashlib.sha1("%s:%s:%s:%s" % (self.nonce_count, nonce, time.ctime(),
  905.                                             randombytes(8))).hexdigest()
  906.         return dig[:16]
  907.  
  908.     def get_authorization(self, req, chal):
  909.         try:
  910.             realm = chal['realm']
  911.             nonce = chal['nonce']
  912.             qop = chal.get('qop')
  913.             algorithm = chal.get('algorithm', 'MD5')
  914.             # mod_digest doesn't send an opaque, even though it isn't
  915.             # supposed to be optional
  916.             opaque = chal.get('opaque', None)
  917.         except KeyError:
  918.             return None
  919.  
  920.         H, KD = self.get_algorithm_impls(algorithm)
  921.         if H is None:
  922.             return None
  923.  
  924.         user, pw = self.passwd.find_user_password(realm, req.get_full_url())
  925.         if user is None:
  926.             return None
  927.  
  928.         # XXX not implemented yet
  929.         if req.has_data():
  930.             entdig = self.get_entity_digest(req.get_data(), chal)
  931.         else:
  932.             entdig = None
  933.  
  934.         A1 = "%s:%s:%s" % (user, realm, pw)
  935.         A2 = "%s:%s" % (req.get_method(),
  936.                         # XXX selector: what about proxies and full urls
  937.                         req.get_selector())
  938.         if qop == 'auth':
  939.             self.nonce_count += 1
  940.             ncvalue = '%08x' % self.nonce_count
  941.             cnonce = self.get_cnonce(nonce)
  942.             noncebit = "%s:%s:%s:%s:%s" % (nonce, ncvalue, cnonce, qop, H(A2))
  943.             respdig = KD(H(A1), noncebit)
  944.         elif qop is None:
  945.             respdig = KD(H(A1), "%s:%s" % (nonce, H(A2)))
  946.         else:
  947.             # XXX handle auth-int.
  948.             pass
  949.  
  950.         # XXX should the partial digests be encoded too?
  951.  
  952.         base = 'username="%s", realm="%s", nonce="%s", uri="%s", ' \
  953.                'response="%s"' % (user, realm, nonce, req.get_selector(),
  954.                                   respdig)
  955.         if opaque:
  956.             base += ', opaque="%s"' % opaque
  957.         if entdig:
  958.             base += ', digest="%s"' % entdig
  959.         base += ', algorithm="%s"' % algorithm
  960.         if qop:
  961.             base += ', qop=auth, nc=%s, cnonce="%s"' % (ncvalue, cnonce)
  962.         return base
  963.  
  964.     def get_algorithm_impls(self, algorithm):
  965.         # lambdas assume digest modules are imported at the top level
  966.         if algorithm == 'MD5':
  967.             H = lambda x: hashlib.md5(x).hexdigest()
  968.         elif algorithm == 'SHA':
  969.             H = lambda x: hashlib.sha1(x).hexdigest()
  970.         # XXX MD5-sess
  971.         KD = lambda s, d: H("%s:%s" % (s, d))
  972.         return H, KD
  973.  
  974.     def get_entity_digest(self, data, chal):
  975.         # XXX not implemented yet
  976.         return None
  977.  
  978.  
  979. class HTTPDigestAuthHandler(BaseHandler, AbstractDigestAuthHandler):
  980.     """An authentication protocol defined by RFC 2069
  981.  
  982.     Digest authentication improves on basic authentication because it
  983.     does not transmit passwords in the clear.
  984.     """
  985.  
  986.     auth_header = 'Authorization'
  987.     handler_order = 490  # before Basic auth
  988.  
  989.     def http_error_401(self, req, fp, code, msg, headers):
  990.         host = urlparse.urlparse(req.get_full_url())[1]
  991.         retry = self.http_error_auth_reqed('www-authenticate',
  992.                                            host, req, headers)
  993.         self.reset_retry_count()
  994.         return retry
  995.  
  996.  
  997. class ProxyDigestAuthHandler(BaseHandler, AbstractDigestAuthHandler):
  998.  
  999.     auth_header = 'Proxy-Authorization'
  1000.     handler_order = 490  # before Basic auth
  1001.  
  1002.     def http_error_407(self, req, fp, code, msg, headers):
  1003.         host = req.get_host()
  1004.         retry = self.http_error_auth_reqed('proxy-authenticate',
  1005.                                            host, req, headers)
  1006.         self.reset_retry_count()
  1007.         return retry
  1008.  
  1009. class AbstractHTTPHandler(BaseHandler):
  1010.  
  1011.     def __init__(self, debuglevel=0):
  1012.         self._debuglevel = debuglevel
  1013.  
  1014.     def set_http_debuglevel(self, level):
  1015.         self._debuglevel = level
  1016.  
  1017.     def do_request_(self, request):
  1018.         host = request.get_host()
  1019.         if not host:
  1020.             raise URLError('no host given')
  1021.  
  1022.         if request.has_data():  # POST
  1023.             data = request.get_data()
  1024.             if not request.has_header('Content-type'):
  1025.                 request.add_unredirected_header(
  1026.                     'Content-type',
  1027.                     'application/x-www-form-urlencoded')
  1028.             if not request.has_header('Content-length'):
  1029.                 request.add_unredirected_header(
  1030.                     'Content-length', '%d' % len(data))
  1031.  
  1032.         scheme, sel = splittype(request.get_selector())
  1033.         sel_host, sel_path = splithost(sel)
  1034.         if not request.has_header('Host'):
  1035.             request.add_unredirected_header('Host', sel_host or host)
  1036.         for name, value in self.parent.addheaders:
  1037.             name = name.capitalize()
  1038.             if not request.has_header(name):
  1039.                 request.add_unredirected_header(name, value)
  1040.  
  1041.         return request
  1042.  
  1043.     def do_open(self, http_class, req):
  1044.         """Return an addinfourl object for the request, using http_class.
  1045.  
  1046.         http_class must implement the HTTPConnection API from httplib.
  1047.         The addinfourl return value is a file-like object.  It also
  1048.         has methods and attributes including:
  1049.             - info(): return a mimetools.Message object for the headers
  1050.             - geturl(): return the original request URL
  1051.             - code: HTTP status code
  1052.         """
  1053.         host = req.get_host()
  1054.         if not host:
  1055.             raise URLError('no host given')
  1056.  
  1057.         h = http_class(host) # will parse host:port
  1058.         h.set_debuglevel(self._debuglevel)
  1059.  
  1060.         headers = dict(req.headers)
  1061.         headers.update(req.unredirected_hdrs)
  1062.         # We want to make an HTTP/1.1 request, but the addinfourl
  1063.         # class isn't prepared to deal with a persistent connection.
  1064.         # It will try to read all remaining data from the socket,
  1065.         # which will block while the server waits for the next request.
  1066.         # So make sure the connection gets closed after the (only)
  1067.         # request.
  1068.         headers["Connection"] = "close"
  1069.         headers = dict(
  1070.             (name.title(), val) for name, val in headers.items())
  1071.         try:
  1072.             h.request(req.get_method(), req.get_selector(), req.data, headers)
  1073.             r = h.getresponse()
  1074.         except socket.error, err: # XXX what error?
  1075.             raise URLError(err)
  1076.  
  1077.         # Pick apart the HTTPResponse object to get the addinfourl
  1078.         # object initialized properly.
  1079.  
  1080.         # Wrap the HTTPResponse object in socket's file object adapter
  1081.         # for Windows.  That adapter calls recv(), so delegate recv()
  1082.         # to read().  This weird wrapping allows the returned object to
  1083.         # have readline() and readlines() methods.
  1084.  
  1085.         # XXX It might be better to extract the read buffering code
  1086.         # out of socket._fileobject() and into a base class.
  1087.  
  1088.         r.recv = r.read
  1089.         fp = socket._fileobject(r, close=True)
  1090.  
  1091.         resp = addinfourl(fp, r.msg, req.get_full_url())
  1092.         resp.code = r.status
  1093.         resp.msg = r.reason
  1094.         return resp
  1095.  
  1096.  
  1097. class HTTPHandler(AbstractHTTPHandler):
  1098.  
  1099.     def http_open(self, req):
  1100.         return self.do_open(httplib.HTTPConnection, req)
  1101.  
  1102.     http_request = AbstractHTTPHandler.do_request_
  1103.  
  1104. if hasattr(httplib, 'HTTPS'):
  1105.     class HTTPSHandler(AbstractHTTPHandler):
  1106.  
  1107.         def https_open(self, req):
  1108.             return self.do_open(httplib.HTTPSConnection, req)
  1109.  
  1110.         https_request = AbstractHTTPHandler.do_request_
  1111.  
  1112. class HTTPCookieProcessor(BaseHandler):
  1113.     def __init__(self, cookiejar=None):
  1114.         import cookielib
  1115.         if cookiejar is None:
  1116.             cookiejar = cookielib.CookieJar()
  1117.         self.cookiejar = cookiejar
  1118.  
  1119.     def http_request(self, request):
  1120.         self.cookiejar.add_cookie_header(request)
  1121.         return request
  1122.  
  1123.     def http_response(self, request, response):
  1124.         self.cookiejar.extract_cookies(response, request)
  1125.         return response
  1126.  
  1127.     https_request = http_request
  1128.     https_response = http_response
  1129.  
  1130. class UnknownHandler(BaseHandler):
  1131.     def unknown_open(self, req):
  1132.         type = req.get_type()
  1133.         raise URLError('unknown url type: %s' % type)
  1134.  
  1135. def parse_keqv_list(l):
  1136.     """Parse list of key=value strings where keys are not duplicated."""
  1137.     parsed = {}
  1138.     for elt in l:
  1139.         k, v = elt.split('=', 1)
  1140.         if v[0] == '"' and v[-1] == '"':
  1141.             v = v[1:-1]
  1142.         parsed[k] = v
  1143.     return parsed
  1144.  
  1145. def parse_http_list(s):
  1146.     """Parse lists as described by RFC 2068 Section 2.
  1147.  
  1148.     In particular, parse comma-separated lists where the elements of
  1149.     the list may include quoted-strings.  A quoted-string could
  1150.     contain a comma.  A non-quoted string could have quotes in the
  1151.     middle.  Neither commas nor quotes count if they are escaped.
  1152.     Only double-quotes count, not single-quotes.
  1153.     """
  1154.     res = []
  1155.     part = ''
  1156.  
  1157.     escape = quote = False
  1158.     for cur in s:
  1159.         if escape:
  1160.             part += cur
  1161.             escape = False
  1162.             continue
  1163.         if quote:
  1164.             if cur == '\\':
  1165.                 escape = True
  1166.                 continue
  1167.             elif cur == '"':
  1168.                 quote = False
  1169.             part += cur
  1170.             continue
  1171.  
  1172.         if cur == ',':
  1173.             res.append(part)
  1174.             part = ''
  1175.             continue
  1176.  
  1177.         if cur == '"':
  1178.             quote = True
  1179.  
  1180.         part += cur
  1181.  
  1182.     # append last part
  1183.     if part:
  1184.         res.append(part)
  1185.  
  1186.     return [part.strip() for part in res]
  1187.  
  1188. class FileHandler(BaseHandler):
  1189.     # Use local file or FTP depending on form of URL
  1190.     def file_open(self, req):
  1191.         url = req.get_selector()
  1192.         if url[:2] == '//' and url[2:3] != '/':
  1193.             req.type = 'ftp'
  1194.             return self.parent.open(req)
  1195.         else:
  1196.             return self.open_local_file(req)
  1197.  
  1198.     # names for the localhost
  1199.     names = None
  1200.     def get_names(self):
  1201.         if FileHandler.names is None:
  1202.             try:
  1203.                 FileHandler.names = (socket.gethostbyname('localhost'),
  1204.                                     socket.gethostbyname(socket.gethostname()))
  1205.             except socket.gaierror:
  1206.                 FileHandler.names = (socket.gethostbyname('localhost'),)
  1207.         return FileHandler.names
  1208.  
  1209.     # not entirely sure what the rules are here
  1210.     def open_local_file(self, req):
  1211.         import email.Utils
  1212.         import mimetypes
  1213.         host = req.get_host()
  1214.         file = req.get_selector()
  1215.         localfile = url2pathname(file)
  1216.         stats = os.stat(localfile)
  1217.         size = stats.st_size
  1218.         modified = email.Utils.formatdate(stats.st_mtime, usegmt=True)
  1219.         mtype = mimetypes.guess_type(file)[0]
  1220.         headers = mimetools.Message(StringIO(
  1221.             'Content-type: %s\nContent-length: %d\nLast-modified: %s\n' %
  1222.             (mtype or 'text/plain', size, modified)))
  1223.         if host:
  1224.             host, port = splitport(host)
  1225.         if not host or \
  1226.            (not port and socket.gethostbyname(host) in self.get_names()):
  1227.             return addinfourl(open(localfile, 'rb'),
  1228.                               headers, 'file:'+file)
  1229.         raise URLError('file not on local host')
  1230.  
  1231. class FTPHandler(BaseHandler):
  1232.     def ftp_open(self, req):
  1233.         import ftplib
  1234.         import mimetypes
  1235.         host = req.get_host()
  1236.         if not host:
  1237.             raise IOError, ('ftp error', 'no host given')
  1238.         host, port = splitport(host)
  1239.         if port is None:
  1240.             port = ftplib.FTP_PORT
  1241.         else:
  1242.             port = int(port)
  1243.  
  1244.         # username/password handling
  1245.         user, host = splituser(host)
  1246.         if user:
  1247.             user, passwd = splitpasswd(user)
  1248.         else:
  1249.             passwd = None
  1250.         host = unquote(host)
  1251.         user = unquote(user or '')
  1252.         passwd = unquote(passwd or '')
  1253.  
  1254.         try:
  1255.             host = socket.gethostbyname(host)
  1256.         except socket.error, msg:
  1257.             raise URLError(msg)
  1258.         path, attrs = splitattr(req.get_selector())
  1259.         dirs = path.split('/')
  1260.         dirs = map(unquote, dirs)
  1261.         dirs, file = dirs[:-1], dirs[-1]
  1262.         if dirs and not dirs[0]:
  1263.             dirs = dirs[1:]
  1264.         try:
  1265.             fw = self.connect_ftp(user, passwd, host, port, dirs)
  1266.             type = file and 'I' or 'D'
  1267.             for attr in attrs:
  1268.                 attr, value = splitvalue(attr)
  1269.                 if attr.lower() == 'type' and \
  1270.                    value in ('a', 'A', 'i', 'I', 'd', 'D'):
  1271.                     type = value.upper()
  1272.             fp, retrlen = fw.retrfile(file, type)
  1273.             headers = ""
  1274.             mtype = mimetypes.guess_type(req.get_full_url())[0]
  1275.             if mtype:
  1276.                 headers += "Content-type: %s\n" % mtype
  1277.             if retrlen is not None and retrlen >= 0:
  1278.                 headers += "Content-length: %d\n" % retrlen
  1279.             sf = StringIO(headers)
  1280.             headers = mimetools.Message(sf)
  1281.             return addinfourl(fp, headers, req.get_full_url())
  1282.         except ftplib.all_errors, msg:
  1283.             raise IOError, ('ftp error', msg), sys.exc_info()[2]
  1284.  
  1285.     def connect_ftp(self, user, passwd, host, port, dirs):
  1286.         fw = ftpwrapper(user, passwd, host, port, dirs)
  1287. ##        fw.ftp.set_debuglevel(1)
  1288.         return fw
  1289.  
  1290. class CacheFTPHandler(FTPHandler):
  1291.     # XXX would be nice to have pluggable cache strategies
  1292.     # XXX this stuff is definitely not thread safe
  1293.     def __init__(self):
  1294.         self.cache = {}
  1295.         self.timeout = {}
  1296.         self.soonest = 0
  1297.         self.delay = 60
  1298.         self.max_conns = 16
  1299.  
  1300.     def setTimeout(self, t):
  1301.         self.delay = t
  1302.  
  1303.     def setMaxConns(self, m):
  1304.         self.max_conns = m
  1305.  
  1306.     def connect_ftp(self, user, passwd, host, port, dirs):
  1307.         key = user, host, port, '/'.join(dirs)
  1308.         if key in self.cache:
  1309.             self.timeout[key] = time.time() + self.delay
  1310.         else:
  1311.             self.cache[key] = ftpwrapper(user, passwd, host, port, dirs)
  1312.             self.timeout[key] = time.time() + self.delay
  1313.         self.check_cache()
  1314.         return self.cache[key]
  1315.  
  1316.     def check_cache(self):
  1317.         # first check for old ones
  1318.         t = time.time()
  1319.         if self.soonest <= t:
  1320.             for k, v in self.timeout.items():
  1321.                 if v < t:
  1322.                     self.cache[k].close()
  1323.                     del self.cache[k]
  1324.                     del self.timeout[k]
  1325.         self.soonest = min(self.timeout.values())
  1326.  
  1327.         # then check the size
  1328.         if len(self.cache) == self.max_conns:
  1329.             for k, v in self.timeout.items():
  1330.                 if v == self.soonest:
  1331.                     del self.cache[k]
  1332.                     del self.timeout[k]
  1333.                     break
  1334.             self.soonest = min(self.timeout.values())
  1335.  
  1336. class GopherHandler(BaseHandler):
  1337.     def gopher_open(self, req):
  1338.         # XXX can raise socket.error
  1339.         import gopherlib  # this raises DeprecationWarning in 2.5
  1340.         host = req.get_host()
  1341.         if not host:
  1342.             raise GopherError('no host given')
  1343.         host = unquote(host)
  1344.         selector = req.get_selector()
  1345.         type, selector = splitgophertype(selector)
  1346.         selector, query = splitquery(selector)
  1347.         selector = unquote(selector)
  1348.         if query:
  1349.             query = unquote(query)
  1350.             fp = gopherlib.send_query(selector, query, host)
  1351.         else:
  1352.             fp = gopherlib.send_selector(selector, host)
  1353.         return addinfourl(fp, noheaders(), req.get_full_url())
  1354.